package org.mte.sak.util;


import java.util.StringTokenizer;

/**
 * Classe di utilità per la gestione delle stringhe.
 *
 * @author Marco Traversari
 * @version $Revision: 1.2 $ $Date: 2012-03-13 13:50:05 $
 */
public class StringHandler {
	
    public static final String[] BOOLEAN_TRUE_VALUES = {"1", "S", "s", "Y", "y", "true"};

	/**
	 * Sostituisce nella stringa <code>text</code> la sottostringa
	 * <code>oldSubText</code> con la sottostringa <code>newSubText</code>.
	 *
	 * @param text la stringa originale.
	 * @param oldSubText la sottostringa da sostituire.
	 * @param newSubText la sottostringa che sostituisce.
	 *
	 * @return la stringa modificata.
	 */
	public static String replaceString(String text, String oldSubText, String newSubText) {
		String leftText = "";
		String newText = "";
		String workText = text;
		int ostPos = -1;
		if (text != null) {
			while ((ostPos = workText.indexOf(oldSubText)) != -1) {
				leftText = workText.substring(0, ostPos);
				workText = workText.substring(ostPos + oldSubText.length());
				newText += leftText + newSubText;
			}
		}
		newText += workText;
		return newText;
	}

	/**
	 * Converte una stringa composta da elementi e da un separatore
	 * in un array.
	 *
	 * @param str
	 * @param delimiter
	 * @return array di stringhe.
	 */
	public static String[] getTokens(String str, String delimiter) {
		String[] tokens = null;
		if(str != null && delimiter != null) {
			if (str.indexOf(delimiter) != -1) {
				StringTokenizer st = new StringTokenizer(str, delimiter);
				tokens = new String[st.countTokens()];
				int i = 0;
				while (st.hasMoreTokens()) {
					tokens[i++] = st.nextToken();
				}
			} else {
				tokens = new String[1];
				tokens[0] = str;
			}
		}
		return tokens;
	}

	/**
	 * Converte una stringa composta da elementi e da un separatore
	 * in un array e provvede ad eliminare spazi bianchi.
	 *
	 * @param str
	 * @param delimiter
	 * @return array di stringhe.
	 */
	public static String[] getTrimTokens(String str, String delimiter) {
		String[] tokens = null;
		if(str != null && delimiter != null) {
			if (str.indexOf(delimiter) != -1) {
				StringTokenizer st = new StringTokenizer(str, delimiter);
				tokens = new String[st.countTokens()];
				int i = 0;
				while (st.hasMoreTokens()) {
					tokens[i++] = st.nextToken().trim();
				}
			} else {
				tokens = new String[1];
				tokens[0] = str;
			}
		}
		return tokens;
	}

	/**
	 * capitalize(String str)
	 *
	 * @param str
	 * @return String.
	 */
	public static String capitalize(String str) {
		return capitalize(str, " ");
	}

	/**
	 * capitalize(String str, String separator)
	 *
	 * @param str
	 * @param separator
	 * @return la stringa con le iniziali in maiuscolo
	 */
	public static String capitalize(String str, String separator) {
		str = str.toLowerCase();
		String[] tokens = getTokens(str, separator);
		String newString = "";
		for (int i = 0; i < tokens.length; i++) {
			newString += tokens[i].substring(0, 1).toUpperCase() + tokens[i].substring(1) + separator;
		}
		if (newString.length() > 1) {
			str = newString.substring(0, newString.length() - 1);
		}
		return str;
	}

	/**
	 * Aggiunge nella stringa specificata in corrispondenza
	 * del carattere indicato un back slash.
	 * @param str
	 * @param ch
	 * @return la stringa trasformata.
	 */
	public static String addBackSlash(String str, char ch) {
		String rstr = "";
		int length = str.length();
		for (int i = 0;  i < length; i++) {
			char c = str.charAt(i);
			if (c == ch) {
				rstr += '\\';
			}
			rstr +=  c;
		}
		return rstr;
	}

/*    *//**
     * Controlla che il valore della stringa sia uguale
     * ad uno dei valori utilizzati per impostare
     * a <code>true</code> un campo booleano.
     *
     * @param value
     * @return true || false
     *//*
    public static boolean checkBoolean(String value) {
        boolean result = false;
        if (value != null) {
        	int length = BOOLEAN_TRUE_VALUES.length;
            for (int i = 0; !result && i < length; i++) {
                if (value.equals(BOOLEAN_TRUE_VALUES[i])) {
                    result = true;
                }
            }
        }
        return result;
    }*/

    /**
     * Codifica una stringa nel formato gestibile per pagine HTML o XML.
     *
     * @param str
     * @return la stringa codificata
     * @deprecated use HTMLEncoder.encode
     */
    public static String encode(String str) {
        String encoded = null;
        if (str != null) {
            encoded = "";
            for (int i = 0;  i < str.length(); i++) {
                char c = str.charAt(i);
                if((c < 'a' || c > 'z')
                    && (c < 'A' || c > 'Z')
                    && (c < '0' || c > '9')
                    && (c != ' ')) {
                    encoded += "&#" + (int) str.charAt(i) + ";";
                } else {
                    encoded += str.charAt(i);
                }
            }
        }
        return encoded;
    }

    /**
     * Decodifica un insieme finito di caratteri codificati
     * per HTML.
     *
     * @param str
     * @return la stringa codificata
     * @deprecated use HTMLDecoder.dencode
     */
    public static String decode(String str) {
        str = StringHandler.replaceString(str, "&gt;", ">");
        str = StringHandler.replaceString(str, "&lt;", "<");
        str = StringHandler.replaceString(str, "&amp;", "&");
        return str;
    }
    
	/**
	 * normalizeSlash
	 * 
	 * isLastSlash è true se l'ultimo carattere di str è '/'
	 * isAdd è true se si vuole che l'ultimo carattere di str sia '/' 
	 *
	 *	isLastSlash		isAdd	action		input str		return str
	 * ----------------------------------------------------------------
	 *	true			true	nothing		/x1/x2/x3/		/x1/x2/x3/
	 *	true			false	remove		/x1/x2/x3/		/x1/x2/x3
	 *	false			true    add			/x1/x2/x3		/x1/x2/x3/
	 *	false			false   nothing		/x1/x2/x3		/x1/x2/x3
	 * 
	 * @param str
	 * @param isAdd
	 * @return str
	 */
	public static String normalizeSlash(String str, boolean isAdd) {
		String fileSeparator = System.getProperty("file.separator");
		int len = str.length();
		boolean isLastSlash = str.substring(len - 1).equals(fileSeparator);		
		if (isLastSlash && !isAdd) {
			str = str.substring(0, len - 1);
		} else if (!isLastSlash && isAdd) {
			str = str + fileSeparator;
		}
		return str;
	}
	
    /**
     * Controlla che il valore della stringa sia uguale
     * ad uno dei valori utilizzati per impostare
     * a <code>true</code> un campo booleano.
     *
     * @param value
     * @return true || false
     */
    public static boolean checkBoolean(String value) {
        boolean result = false;
        if (value != null) {
        	int length = BOOLEAN_TRUE_VALUES.length;
            for (int i = 0; !result && i < length; i++) {
                if (value.equals(BOOLEAN_TRUE_VALUES[i])) {
                    result = true;
                }
            }
        }
        return result;
    }
}

